home *** CD-ROM | disk | FTP | other *** search
/ Ian & Stuart's Australian Mac 1993 September / September 93.iso / Archives / Utilities / Graphic / Conversion / viewers / GL Viewer 1.1.1 / src ƒ / parser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-06  |  6.1 KB  |  345 lines  |  [TEXT/KAHL]
  1. /*
  2.  * parser.c - grasp language file parser.
  3.  *
  4.  * Copyright (c) 1991 by Patrick J. Naughton
  5.  */
  6.  
  7. #pragma segment Parser
  8.  
  9. #include "grasp.h"
  10.  
  11. char       *tokens[] = {
  12.     "notoken",
  13.     "box",
  14.     "break",
  15.     "call",
  16.     "cfade",
  17.     "cfree",
  18.     "cgetbuf",
  19.     "chgcolor",
  20.     "circle",
  21.     "clearscr",
  22.     "cload",
  23.     "closegl",
  24.     "color",
  25.     "cycle",
  26.     "data",
  27.     "databegin",
  28.     "dataend",
  29.     "dataskip",
  30.     "dfree",
  31.     "dload",
  32.     "edge",
  33.     "else",
  34.     "endlfloat",
  35.     "endif",
  36.     "exec",
  37.     "exit",
  38.     "ffree",
  39.     "fgaps",
  40.     "fload",
  41.     "float",
  42.     "fly",
  43.     "font",
  44.     "fstyle",
  45.     "getcolor",
  46.     "getkey",
  47.     "gosub",
  48.     "goto",
  49.     "if",
  50.     "ifkey",
  51.     "ifmem",
  52.     "ifmouse",
  53.     "ifvideo",
  54.     "int",
  55.     "line",
  56.     "link",
  57.     "local",
  58.     "loop",
  59.     "mark",
  60.     "merge",
  61.     "mode",
  62.     "mouse",
  63.     "move",
  64.     "noise",
  65.     "note",
  66.     "offset",
  67.     "opengl",
  68.     "out",
  69.     "palette",
  70.     "pan",
  71.     "pfade",
  72.     "pfree",
  73.     "pgetbuf",
  74.     "pload",
  75.     "pnewbuf",
  76.     "point",
  77.     "poke",
  78.     "pokel",
  79.     "pokew",
  80.     "pop",
  81.     "position",
  82.     "psave",
  83.     "psetbuf",
  84.     "putoff",
  85.     "putup",
  86.     "rect",
  87.     "resetgl",
  88.     "resetscr",
  89.     "return",
  90.     "revpage",
  91.     "send",
  92.     "set",
  93.     "setcolor",
  94.     "setpage",
  95.     "setrgb",
  96.     "setupscr",
  97.     "split",
  98.     "spread",
  99.     "text",
  100.     "tile",
  101.     "timer",
  102.     "tran",
  103.     "video",
  104.     "waitkey",
  105.     "when",
  106.     "window",
  107.     "fade",
  108.     "wait",
  109. };
  110.  
  111. static char *
  112. sows(ptr)
  113.     char       *ptr;
  114. {
  115.     int         incomment = 0;
  116.  
  117.     while (incomment || *ptr == ' ' || *ptr == '\t' || *ptr == '\r' ||
  118. #if 0
  119.         *ptr == '.' ||            // for common typo  :-(
  120. #endif
  121.         *ptr == ',' || *ptr == ';') {
  122.     if (*ptr == ';')
  123.         incomment = 1;
  124.     else if (*ptr == '\n')
  125.         break;
  126.     ptr++;
  127.     }
  128.     return ptr;
  129. }
  130.  
  131. static char *
  132. sowsanl(ptr)
  133.     char       *ptr;
  134. {
  135.     int         incomment = 0;
  136.  
  137.     while (incomment || *ptr == ' ' || *ptr == '\t' || *ptr == '\r' ||
  138. #if 0
  139.         *ptr == '.' ||            // for common typo :-(
  140. #endif
  141.         *ptr == ',' || *ptr == ';' || *ptr == '\n') {
  142.     if (*ptr == ';')
  143.         incomment = 1;
  144.     else if (*ptr == '\n' || *ptr == 26)
  145.         incomment = 0;
  146.     ptr++;
  147.     }
  148.     return ptr;
  149. }
  150.  
  151. static char *
  152. copytoken(src, dst)
  153.     char       *src;
  154.     char       *dst;
  155. {
  156.     src = sowsanl(src);
  157.     if (*src == '"') {
  158.     src++;
  159.     while (*src != '"' && *src != '\n' && *src != '\r')
  160.         *dst++ = *src++;
  161.     if (*src != '\n')
  162.         src++;
  163.     } else
  164.     while (*src != ' ' && *src != '\t' && *src != '\r' &&
  165. #if 0
  166.         *src != '.' &&            // for common typo  :-(
  167. #endif
  168.         *src != ',' && *src != '\n' && *src != 26) {
  169.         if (*src >= 'A' && *src <= 'Z')
  170.         *dst++ = *src++ + 'a' - 'A';    /* tolower */
  171.         else
  172.         *dst++ = *src++;
  173.     }
  174.     *dst = 0;
  175.     src = sows(src);
  176.     return src;
  177. }
  178.  
  179. static int
  180. lookuptoken(ptr)
  181.     char       *ptr;
  182. {
  183.     int         i;
  184.  
  185.     if (ptr[strlen(ptr) - 1] != ':')
  186.     for (i = 1; i < NTOKENS; i++)
  187.         if (!strcmp(ptr, tokens[i]))
  188.         return i;
  189.  
  190.     return NOTOKEN;
  191. }
  192.  
  193. static int
  194. tokentoint(s, ret)
  195.     char       *s;
  196.     int        *ret;
  197. {
  198.     int         i;
  199.     for (i = 0; i < strlen(s); i++)
  200.     if (!isdigit(s[i]) && s[i] != '-')
  201.         return 0;
  202.     sscanf(s, "%d", ret);
  203.     return 1;
  204. }
  205.  
  206. static void
  207. addlabel(ex, s)
  208.     ExecStruct *ex;
  209.     char       *s;
  210. {
  211.     ex->label[ex->numlabels].string = strdup(s);
  212.     ex->label[ex->numlabels].ipaddr = ex->numcodes;
  213.     if (++(ex->numlabels) >= MAXLABELS)
  214.     error("%s: too many labels!", NULL);
  215. }
  216.  
  217. static void
  218. addargcount(ex, tokenaddr)
  219.     ExecStruct *ex;
  220.     int         tokenaddr;
  221. {
  222.     ex->Code[tokenaddr].val.i = ex->numcodes - tokenaddr - 1;
  223. }
  224.  
  225. static void
  226. addtoken(ex, t)
  227.     ExecStruct *ex;
  228.     int         t;
  229. {
  230.     ex->Code[ex->numcodes].token = t;
  231.     if (++(ex->numcodes) >= MAXCODES)
  232.     error("%s: text file too large. can only have %d tokens\n", (char *) MAXCODES);
  233. }
  234.  
  235. static void
  236. addstring(ex, string)
  237.     ExecStruct *ex;
  238.     char       *string;
  239. {
  240.     ex->Code[ex->numcodes].val.s = strdup(string);
  241.     addtoken(ex, STRING);
  242. }
  243.  
  244. static void
  245. addint(token, arg, ex, string, integer)
  246.     int         token;
  247.     int         arg;
  248.     ExecStruct *ex;
  249.     char       *string;
  250.     int         integer;
  251. {
  252.     /*
  253.      * make sure we don't convert a string that happens to parse as a number
  254.      * such as a filename, or keyname, or video mode, into an integer
  255.      */
  256.     if (((token == CLOAD || token == PLOAD || token == FLOAD)
  257.      && (arg == 1))
  258.         || (token == TEXT && arg == 3)
  259.         || (token == VIDEO || token == IFKEY))
  260.     addstring(ex, string);
  261.     else {
  262.     ex->Code[ex->numcodes].val.i = integer;
  263.     addtoken(ex, INTEGER);
  264.     }
  265. }
  266.  
  267. void
  268. parsefile(ex, ptr)
  269.     ExecStruct *ex;
  270.     char       *ptr;
  271. {
  272.     char        buffer[100];
  273.     int         tokenaddr;
  274.     char       *pOrig = ptr;
  275.  
  276.  
  277.     ex->numcodes = 0;
  278.     ex->numlabels = 0;
  279.     do {
  280.     int         i;
  281.     int         token;
  282.  
  283.     ptr = copytoken(ptr, buffer);
  284.     if (buffer[0] == 0)
  285.         break;
  286.     if (buffer[strlen(buffer) - 1] == ':') {
  287.         buffer[strlen(buffer) - 1] = 0;
  288.         addlabel(ex, buffer);
  289.         while (*ptr != '\n' && *ptr != 26)
  290.         ptr++;
  291.     } else {
  292.         int         range;
  293.         int         start;
  294.  
  295.         token = lookuptoken(buffer);
  296.         if (token == NOTOKEN) {
  297.         if (tokentoint(buffer, &i))
  298.             addint(token, 0, ex, buffer, i);
  299.         else
  300.             addstring(ex, buffer);
  301.         tokenaddr = -1;
  302.         } else {
  303.         tokenaddr = ex->numcodes;
  304.         addtoken(ex, token);
  305.         }
  306.  
  307.         range = 0;
  308.         while (*ptr != '\n' && *ptr != 26) {
  309.         int         arg = ex->numcodes - tokenaddr;
  310.         ptr = copytoken(ptr, buffer);
  311.         if (range) {
  312.             if (tokentoint(buffer, &i)) {
  313.             int         val;
  314.             if (i >= start)
  315.                 for (val = start; val <= i; val++)
  316.                 addint(token, arg, ex, buffer, val);
  317.             else
  318.                 for (val = start; val >= i; val--)
  319.                 addint(token, arg, ex, buffer, val);
  320.             range = 0;
  321.             } else
  322.             error("%s: parse error on int range\n", NULL);
  323.  
  324.         } else {
  325.             if (buffer[0] == '-' && buffer[1] == 0) {
  326.             range = 1;
  327.             } else {
  328.             if (tokentoint(buffer, &i)) {
  329.                 addint(token, arg, ex, buffer, i);
  330.                 start = i;
  331.             } else
  332.                 addstring(ex, buffer);
  333.             }
  334.         }
  335.         }
  336.         if (tokenaddr != -1)
  337.         addargcount(ex, tokenaddr);
  338.     }
  339.  
  340.     if (*ptr == 26)
  341.         break;
  342.     ptr++;
  343.     } while (*ptr != 26);
  344. }
  345.